package com.bankcomm.ui.specialwidget;

import java.util.Iterator;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import android.app.Activity;
import android.app.Dialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.DialogInterface.OnDismissListener;
import android.view.Gravity;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.view.Window;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.LinearLayout;
import android.widget.AbsoluteLayout.LayoutParams;
import com.rytong.tools.ui.ArrayWheelAdapter;
import com.rytong.tools.ui.Component;
import com.rytong.tools.ui.CssStyle;
import com.rytong.tools.ui.LPSelect;
import com.rytong.tools.ui.LPSelectOption;
import com.rytong.tools.ui.OnWheelScrollListener;
import com.rytong.tools.ui.WheelView;
import com.rytong.tools.utils.Utils;

/**
 * 省市选择select。
 */
public class LPDoubleSelect extends LPSelect {
	
	/**
	 * 省份的名字数组。
	 */
	private String[] provinceNames_ = null;
	/**
	 * 回执单
	 */
	private String[] proTranCodes = null;
	/**
	 * 城市的名字数组。
	 */
	private String[][] cityNames_ = null;
	/**
	 * 用来存放结果的option。
	 */
	private LPSelectOption resultOption_ = null;
	/**
	 * 最长的省份名字的长度。
	 */
	private int maxProvinceLength_ = 0;
	/**
	 * 最长的城市名字的长度。
	 */
	private int maxCityLength_ = 0;
	
	public class MyLPDoubleSelect extends MyLPSelect{

		public MyLPDoubleSelect(Context context) {
			super(context);
		}
		
		@Override
		public Component composited() {
			return LPDoubleSelect.this;
		}
	}
	
	@Override
	public void initRealView(Activity activity, String value) {
		super.initRealView(activity, value);
		realView_ = new MyLPDoubleSelect(activity);
	}
	
	@Override
	public void mouldH() throws Exception {
		super.mouldH();
		// 拿到表示省市的Json字符串。
		String pickerinfoData = getPropertyByName("pickerinfo");
		// 解析这个字符串。
		parsePickerinfoData(pickerinfoData);
		LayoutParams viewLayout = null;
        viewLayout = (LayoutParams) getLayoutParams();
        /**
         * 计算select的宽度，如果后台指定了宽度，就使用后台给定的值，
         * 如果不指定，那么就取option中内容最多的那段文字的宽度，
         */
        if(cssStyle_ != null && cssStyle_.getProperty(CssStyle.WIDTH) != null
        		&& !"".equalsIgnoreCase(cssStyle_.getProperty(CssStyle.WIDTH))){
        	// 这里后台给定了宽度，在super.muold()中宽度已经计算出来了，此处不进行宽度的计算。
        } else { // 计算出最长option的长度。
        	int maxLength = maxProvinceLength_ + maxCityLength_;
            if(maxLength > 0){ // 如果算出来了最长宽度，那么就使用这个值，否则将采用默认的widget中规定的值。
            	viewLayout.width = maxLength;
            }
        }
        setLayoutParams(viewLayout);
	}
	
	/**
	 * 解析省市Json字符串。并把省市名字存进数组。
	 * 
	 * @param pickerinfoData 待解析的省市Json字符串。
	 */
	private void parsePickerinfoData(String pickerinfoData){
		try {
			JSONArray provinces = new JSONArray(pickerinfoData); // 其实拿出来的是省份数组。
			// 如果解析出来确实有内容。
			if(provinces != null && provinces.length() > 0){
				provinceNames_ = new String[provinces.length()];
                cityNames_ = new String[provinces.length()][];
                
                int provinceSize = provinces.length(); // 省份数组的数量。
                JSONObject provinceObject = null; // 解析Json对象时候要使用的对象。
                String pName = null; // 省份名称。
                String pCode = null;//回执单
                Object pvalue = null; // 省份对应的值。
                JSONArray cityJson = null; // 城市数组。
                int citySize = 0; // 城市的数量。
                JSONObject cityObject = null; // 解析出来的一个城市。
                String cityName = null; // 城市的名字。
                for (int i = 0; i < provinceSize; i++) {
                	provinceObject = new JSONObject(provinces.getString(i)); // 拿到一个省份。
                	Iterator iterator = provinceObject.keys();
                	while(iterator.hasNext()){
                		pName = iterator.next().toString();
                		if(null != pName && pName.equalsIgnoreCase("pTranCode")){
            				proTranCodes = new String[provinces.length()];
                			pCode = provinceObject.getString(pName);
                			if(pCode != null && !"".equals(pCode)){
                				proTranCodes[i] = pCode;
                			}else{
                				proTranCodes[i] = "";
                			}                			
                		}else{
                            if(pName != null && !"".equals(pName)){
                            	maxProvinceLength_ = (int) Math.max(maxProvinceLength_, getPaint().measureText(pName));
                            	provinceNames_[i] = pName; // 记录省份名称。
                            	pvalue = provinceObject.get(pName); // 拿省份对应的值。
                            	if (pvalue instanceof JSONArray) { // 如果一个省份还含有城市字符串，就进一步解析。
                            		cityJson = new JSONArray(pvalue.toString());
                            		if (cityJson.length() > 0) { // 如果这个省份有城市列表的话。
                            			citySize = cityJson.length(); // 确定城市个数。
                            			cityNames_[i] = new String[citySize];
                            			for (int j = 0; j < citySize; j++) {
                            				cityObject = new JSONObject(cityJson.getString(j)); // 拿出一个城市。
                            				cityName = cityObject.keys().next().toString(); // 拿到城市的名字。
                            				if(cityName != null && !"".equals(cityName)
                            						&& !cityName.equals(pName)){ // 重复的省和市只存储省份名称。
                            					cityNames_[i][j] = cityName; // 记录城市的名字。
                            					maxCityLength_ = (int) Math.max(maxCityLength_, getPaint().measureText(cityName));
                            				} else {
                            					cityNames_[i][j] = "";
                            				}
                            			}
                            		}
                            	}
                            } else {
                            	provinceNames_[i] = "";
                            }
                		}
                	}
                }
			}
		} catch (JSONException e) {
			e.printStackTrace();
		}
	}
	
	@Override
	public void showAndroidWheel(Context context, final Component[] views,
			final LPSelect currentSelect) {
		// 拿到用来存放结果的option。
		if(resultOption_ == null && childrenList_ != null && childrenList_.size() >= 1
				&& childrenList_.get(0) instanceof LPSelectOption){
			resultOption_ = (LPSelectOption) childrenList_.get(0);
		}
		// 拿初始值。默认省市的初始值都拿第一个。
		int provinceNumber = 0;
		int cityNumber = 0;
		if(resultOption_ != null && provinceNames_ != null && cityNames_ != null){
			String resultString = resultOption_.getPropertyByName("value");
			// 如果结果option的value只给了省份的名称，那么省份和城市都拿这一个value值。
			if(null != resultString && !"".equalsIgnoreCase(resultString)){
				String[] xx = resultString.split(":");
				// 拿省份序号。
				for (int i = 0; i < provinceNames_.length; i++) {
					if(xx[0].trim().equals(provinceNames_[i])){
						provinceNumber = i;
						break;
					}
				}
				// 拿上边省份对应的城市序号。
				if(xx.length >= 2){
					for (int i = 0; i < cityNames_[provinceNumber].length; i++) {
						if(xx[1].trim().equals(cityNames_[provinceNumber][i])){
							cityNumber = i;
							break;
						}
					}
				}else{
					for (int i = 0; i < cityNames_[provinceNumber].length; i++) {
						if(resultString.equals(cityNames_[provinceNumber][i])){
							cityNumber = i;
							break;
						}
					}
				}
			}
		} else { // 如果发现模板没有写默认的option，或者解析Json数据不成功，那么就撤销已有的对话框，并且不做任何操作。
			LPSelect.ISPOPING = false;
			return;
		}
		// 需要在select控件中显示的视图。
		View view = LayoutInflater.from(context).inflate(
				Utils.getResourcesId(context, "layout_select_popup", "layout"),
				null);
		LinearLayout parent = (LinearLayout) view.findViewById(Utils
				.getResourcesId(context, "wheelParent", "id"));
		// 需要显示的两个滚轮。其实两个滚轮的宽度和应该为300。
		// 省份滚轮。
		final WheelView provinceWheel = new WheelView((Activity) context);
		provinceWheel.setLayoutParams(new LinearLayout.LayoutParams(
				Utils.getScaledValueX(150), LayoutParams.FILL_PARENT));
		provinceWheel.setPadding(5, 5, 5, 5);
		provinceWheel.setAdapter(new ArrayWheelAdapter<String>(provinceNames_));
		provinceWheel.setCurrentItem(provinceNumber);
		parent.addView(provinceWheel);
		// 城市滚轮。
		final WheelView cityWheel = new WheelView((Activity) context);
		cityWheel.setLayoutParams(new LinearLayout.LayoutParams(
				Utils.getScaledValueX(150), LayoutParams.FILL_PARENT));
		cityWheel.setPadding(5, 5, 5, 5);
		cityWheel.setAdapter(new ArrayWheelAdapter<String>(cityNames_[provinceNumber]));
		cityWheel.setCurrentItem(cityNumber);
		parent.addView(cityWheel);
		// 省份滚轮需要和城市滚轮做一个联动。
		provinceWheel.addScrollingListener(new OnWheelScrollListener() {
					
			@Override
			public void onScrollingStarted(WheelView wheel) {
			}
					
			@Override
			public void onScrollingFinished(WheelView wheel) {
				// 拿到滚动结束时候的省份序号。
				int endScrollProvinceNumber = provinceWheel.getCurrentItem();
				cityWheel.setCurrentItem(0, true);
				cityWheel.setAdapter(new ArrayWheelAdapter<String>(cityNames_[endScrollProvinceNumber]));
			}
		});
		// 设置弹出框的动画。
		int styleId = Utils.getResourcesId(context, "popupAnimation", "style");
		final Dialog mCertDialog = new Dialog(context, styleId);
		mCertDialog.setContentView(view);
		mCertDialog.setCancelable(true);
		// mCertDialog.setCanceledOnTouchOutside(true);

		Window mWindow = mCertDialog.getWindow();
		mWindow.setWindowAnimations(styleId);
		mWindow.setGravity(Gravity.BOTTOM | Gravity.FILL_HORIZONTAL);
		mWindow.setLayout(ViewGroup.LayoutParams.FILL_PARENT,
				ViewGroup.LayoutParams.WRAP_CONTENT);

		Button confirm = (Button) view.findViewById(Utils.getResourcesId(
				context, "confirm", "id"));
		Button cancel = (Button) view.findViewById(Utils.getResourcesId(
				context, "cancel", "id"));

		// 确定按钮
		confirm.setOnClickListener(new OnClickListener() {

			public void onClick(View v) {
				// 获得选择结果。
				String provinceGet = provinceNames_[provinceWheel.getCurrentItem()];
				String cityGet = cityNames_[provinceWheel.getCurrentItem()][cityWheel.getCurrentItem()];
				// 赋值结果option和页面展现。
				if(provinceGet != null){
					boolean isNull = false;
					if(cityGet == null || "".equalsIgnoreCase(cityGet)){
						isNull = true;
						cityGet = " ";
					}
					String value = "";
					if(null != proTranCodes){
						String tranCodeGet = proTranCodes[provinceWheel.getCurrentItem()];
						if(tranCodeGet == null || "".equalsIgnoreCase(tranCodeGet)){
							tranCodeGet = " ";
						}
						value= provinceGet+":"+(isNull ? provinceGet:cityGet)+":"+tranCodeGet;
					}else{
						value= provinceGet+":"+(isNull ? provinceGet:cityGet);
					}
					
					resultOption_.setPropertyByName("value", value);
					resultOption_.setPropertyByName("text", ("".equals(cityGet) ? provinceGet
							: provinceGet + cityGet));
					currentSelect.setCurrentMenu(0);
					currentSelect.setContentText(resultOption_.getPropertyByName("text"), 
							resultOption_.getPropertyByName("value"));
					attrValue_ = resultOption_.getPropertyByName("value");
					currentSelect.invalidate();
					LPSelect.ISPOPING = false;
				}
				mCertDialog.dismiss();
			}
		});

		cancel.setOnClickListener(new OnClickListener() {
			public void onClick(View v) {
				LPSelect.ISPOPING = false;
				mCertDialog.dismiss();
			}
		});

		if (null != mCertDialog && !mCertDialog.isShowing()) {
			mCertDialog.show();
			mCertDialog.setOnDismissListener(new OnDismissListener() {

				public void onDismiss(DialogInterface dialog) {
					LPSelect.ISPOPING = false;
				}
			});
		}
	}
}